@dxos/ui-editor 0.10.0 → 0.11.1

package/dist/lib/chunk-diff.mjs

@@ -0,0 +1,935 @@
+import { EditorSelection, Facet, StateEffect, StateField, Text, Transaction } from "@codemirror/state";
+import { Decoration, EditorView, RectangleMarker, ViewPlugin, keymap, layer } from "@codemirror/view";
+import { isNonNullable, isTruthy } from "@dxos/util";
+import * as Schema from "effect/Schema";
+import { debounce } from "@dxos/async";
+import { log } from "@dxos/log";
+import { invertedEffects } from "@codemirror/commands";
+import { Chunk, getChunks, unifiedMergeView } from "@codemirror/merge";
+import sortBy from "lodash.sortby";
+import { diffWordsWithSpace } from "diff";
+//#region src/util/facet.ts
+var singleValueFacet = (defaultValue) => Facet.define({ combine: (providers) => {
+	return providers[0] ?? defaultValue;
+} });
+//#endregion
+//#region src/util/cursor.ts
+/**
+* Determines if two ranges overlap.
+* A range is considered to overlap if there is any intersection
+* between the two ranges, inclusive of their boundaries.
+*/
+var overlap = (a, b) => a.from <= b.to && a.to >= b.from;
+var defaultCursorConverter = {
+	toCursor: (position) => position.toString(),
+	fromCursor: (cursor) => parseInt(cursor)
+};
+var Cursor = class Cursor {
+	static converter = singleValueFacet(defaultCursorConverter);
+	static getCursorFromRange = (state, range) => {
+		const cursorConverter = state.facet(Cursor.converter);
+		return [cursorConverter.toCursor(range.from), cursorConverter.toCursor(range.to, -1)].join(":");
+	};
+	static getRangeFromCursor = (state, cursor) => {
+		const cursorConverter = state.facet(Cursor.converter);
+		const parts = cursor.split(":");
+		const from = cursorConverter.fromCursor(parts[0]);
+		const to = cursorConverter.fromCursor(parts[1]);
+		return from !== void 0 && to !== void 0 ? {
+			from,
+			to
+		} : void 0;
+	};
+};
+//#endregion
+//#region src/util/debug.ts
+var __dxlog_file$1 = "/__w/dxos/dxos/packages/ui/ui-editor/src/util/debug.ts";
+var join = (...lines) => lines.join("\n");
+/**
+* CodeMirror callbacks swallow errors so wrap handlers.
+*/
+var wrapWithCatch = (fn, label) => {
+	return (...args) => {
+		try {
+			return fn(...args);
+		} catch (err) {
+			log.catch(err, { label }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 20,
+				S: void 0
+			});
+		}
+	};
+};
+/**
+* Log all changes before dispatching them to the view.
+* https://codemirror.net/docs/ref/#view.EditorView.dispatch
+*/
+var debugDispatcher = (trs, view) => {
+	logChanges(trs);
+	view.update(trs);
+};
+/**
+* Util to log transactions in update listener.
+*/
+var logChanges = (trs) => {
+	const changes = trs.flatMap((tr) => {
+		if (tr.changes.empty) return;
+		const changes = [];
+		tr.changes.iterChanges((fromA, toA, fromB, toB, inserted) => changes.push(JSON.stringify({
+			fromA,
+			toA,
+			fromB,
+			toB,
+			inserted: inserted.toString()
+		})));
+		return changes;
+	}).filter(Boolean);
+	if (changes.length) log("changes", { changes }, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file$1,
+		L: 54,
+		S: void 0
+	});
+};
+//#endregion
+//#region src/extensions/state/selection.ts
+/**
+* Currently edited document id as FQ string.
+*/
+var documentId = singleValueFacet();
+var EditorSelection$1 = Schema.Struct({
+	anchor: Schema.Number,
+	head: Schema.optional(Schema.Number)
+}).pipe(Schema.mutable);
+var EditorSelectionStateSchema = Schema.Struct({
+	scrollTo: Schema.optional(Schema.Number),
+	selection: Schema.optional(EditorSelection$1)
+}).pipe(Schema.mutable);
+var stateRestoreAnnotation = "org.dxos.cm.state-restore";
+var createEditorStateTransaction = ({ scrollTo, selection }) => {
+	return {
+		selection,
+		scrollIntoView: !scrollTo,
+		effects: scrollTo ? EditorView.scrollIntoView(scrollTo, { yMargin: 96 }) : void 0,
+		annotations: Transaction.userEvent.of(stateRestoreAnnotation)
+	};
+};
+/**
+* Track scrolling and selection state to be restored when switching to document.
+*/
+var selectionState = ({ getState, setState } = {}) => {
+	const setStateDebounced = debounce(setState, 1e3);
+	return [EditorView.updateListener.of(({ view, transactions }) => {
+		const id = view.state.facet(documentId);
+		if (!id || transactions.some((tr) => tr.isUserEvent(stateRestoreAnnotation))) return;
+		if (setState) {
+			const { scrollTop } = view.scrollDOM;
+			const pos = view.posAtCoords({
+				x: 0,
+				y: scrollTop
+			});
+			if (pos !== null) {
+				const { anchor, head } = view.state.selection.main;
+				setStateDebounced(id, {
+					scrollTo: pos,
+					selection: {
+						anchor,
+						head
+					}
+				});
+			}
+		}
+	}), getState && keymap.of([{
+		key: "Ctrl-r",
+		run: (view) => {
+			const state = getState(view.state.facet(documentId));
+			if (state && (state.scrollTo != null || state.selection)) view.dispatch(createEditorStateTransaction(state));
+			return true;
+		}
+	}])].filter(isTruthy);
+};
+//#endregion
+//#region src/extensions/review/comments.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/ui/ui-editor/src/extensions/review/comments.ts";
+/**
+* Comment threads.
+* 1). Updates the EditorModel to store relative selections for a set of comments threads.
+*     Since the selections are relative, they do not need to be updated when the document is edited.
+* 2). Implements a StateField to track absolute selections corresponding to the comments (i.e., when the document is edited).
+* 3). Creates decoration marks to apply classes to each selection.
+* 4). Tracks the current cursor position to:
+*     a). Update the decoration to show if the cursor is within a current selection.
+*     b). Calls a handler to indicate which is the closest selection (e.g., to update the thread sidebar).
+* 5). Optionally, implements a hoverTooltip to show hints when creating a selection range.
+*/
+var comments = (options) => {
+	const { key: shortcut = "meta-'" } = options;
+	const handleSelect = debounce((state) => options.onSelect?.(state), 200);
+	return [
+		optionsFacet.of(options),
+		options.id ? documentId.of(options.id) : void 0,
+		commentsState,
+		commentsDecorations,
+		commentsHighlightLayer,
+		handleCommentClick,
+		styles,
+		ViewPlugin.fromClass(class {
+			unsubscribe;
+			constructor(view) {
+				const { id } = options;
+				const updateComments = () => {
+					const comments = options.getComments?.() ?? [];
+					if (id && id === view.state.facet(documentId)) queueMicrotask(() => view.dispatch({ effects: setComments.of({
+						id,
+						comments
+					}) }));
+				};
+				this.unsubscribe = options.subscribe?.(updateComments) ?? (() => {});
+				updateComments();
+			}
+			destroy = () => {
+				this.unsubscribe();
+			};
+		}),
+		options.onCreate && keymap.of([{
+			key: shortcut,
+			run: wrapWithCatch(createComment)
+		}]),
+		EditorView.updateListener.of(({ view, state, changes }) => {
+			let mod = false;
+			const { comments, ...value } = state.field(commentsState);
+			changes.iterChanges((from, to, from2, to2) => {
+				comments.forEach(({ comment, range }) => {
+					if (!comment.cursor) return;
+					if (from2 === to2) {
+						const newRange = Cursor.getRangeFromCursor(view.state, comment.cursor);
+						if (!newRange || newRange.to - newRange.from === 0) options.onDelete?.({ id: comment.id });
+					}
+					if (from <= range.to) {
+						const newRange = Cursor.getRangeFromCursor(view.state, comment.cursor);
+						Object.assign(range, newRange);
+						mod = true;
+					}
+				});
+			});
+			if (mod) view.dispatch({ effects: setCommentState.of({
+				comments,
+				...value
+			}) });
+		}),
+		EditorView.updateListener.of(({ view, state, transactions }) => {
+			let min = Infinity;
+			const { selection: applied, comments } = state.field(commentsState);
+			const { current, closest } = applied;
+			const notify = (selection) => handleSelect({
+				selection,
+				id: state.facet(documentId),
+				comments: comments.map(({ comment, range }) => ({
+					comment,
+					range,
+					location: view.coordsAtPos(range.from)
+				}))
+			});
+			if (transactions.some((tr) => tr.effects.some((effect) => effect.is(setSelection)))) {
+				notify(applied);
+				return;
+			}
+			const { head } = state.selection.main;
+			const selection = {};
+			comments.forEach(({ comment, range }) => {
+				if (head >= range.from && head <= range.to) {
+					selection.current = comment.id;
+					selection.closest = void 0;
+				}
+				if (!selection.current) {
+					const d = Math.min(Math.abs(head - range.from), Math.abs(head - range.to));
+					if (d < min) {
+						selection.closest = comment.id;
+						min = d;
+					}
+				}
+			});
+			if (selection.current !== current || selection.closest !== closest) {
+				view.dispatch({ effects: setSelection.of(selection) });
+				notify(selection);
+			}
+		}),
+		options.onUpdate && trackPastedComments(options.onUpdate)
+	].filter(isNonNullable);
+};
+var setComments = StateEffect.define();
+var setSelection = StateEffect.define();
+var setCommentState = StateEffect.define();
+/**
+* State field (reducer) that tracks comment ranges.
+* The ranges are tracked as Automerge cursors from which the absolute indexed ranges can be computed.
+* Included by {@link comments}; exported for direct state reads.
+*/
+var commentsState = StateField.define({
+	create: (state) => ({
+		id: state.facet(documentId),
+		comments: [],
+		selection: {}
+	}),
+	update: (value, tr) => {
+		for (const effect of tr.effects) {
+			if (effect.is(setSelection)) return {
+				...value,
+				selection: effect.value
+			};
+			if (effect.is(setComments)) {
+				const { comments } = effect.value;
+				const commentStates = comments.map((comment) => {
+					if (!comment.cursor) return;
+					const range = Cursor.getRangeFromCursor(tr.state, comment.cursor);
+					return range && {
+						comment,
+						range
+					};
+				}).filter(isNonNullable);
+				return {
+					...value,
+					comments: commentStates
+				};
+			}
+			if (effect.is(setCommentState)) return effect.value;
+		}
+		return value;
+	}
+});
+var createCommentMark = (id, isCurrent) => Decoration.mark({
+	class: "cm-comment",
+	attributes: {
+		"data-testid": "cm-comment",
+		"data-comment-id": id,
+		"data-current": isCurrent ? "1" : "0"
+	}
+});
+/**
+* Transparent inline marks that carry `data-comment-id` for click routing (see `handleCommentClick`).
+* The colour comes from `commentsHighlightLayer`.
+*/
+var commentsDecorations = EditorView.decorations.compute([commentsState], (state) => {
+	const { selection: { current }, comments } = state.field(commentsState);
+	const decorations = sortBy(comments ?? [], (range) => range.range.from)?.flatMap((comment) => {
+		const range = comment.range;
+		if (!range) {
+			log.warn("Invalid range:", range, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 342,
+				S: void 0
+			});
+			return;
+		} else if (range.from === range.to) return;
+		return createCommentMark(comment.comment.id, comment.comment.id === current).range(range.from, range.to);
+	}).filter(isNonNullable);
+	return Decoration.set(decorations);
+});
+/**
+* Selection-style highlight: draws each comment range as a layer of rectangle markers below the text.
+* `RectangleMarker.forRange` extends wrapped (non-final) lines to the line edge, so a multi-line comment
+* reads as one continuous block rather than ragged per-word inline backgrounds.
+*/
+var commentsHighlightLayer = layer({
+	above: false,
+	class: "cm-commentsHighlightLayer",
+	update: (update) => update.docChanged || update.viewportChanged || update.geometryChanged || update.selectionSet || update.transactions.some((tr) => tr.effects.some((effect) => effect.is(setSelection) || effect.is(setComments) || effect.is(setCommentState))),
+	markers: (view) => {
+		const { selection: { current }, comments } = view.state.field(commentsState);
+		return sortBy(comments ?? [], (comment) => comment.range.from).flatMap((comment) => {
+			const { from, to } = comment.range;
+			if (from >= to) return [];
+			const className = comment.comment.id === current ? "cm-comment-highlight cm-comment-highlight-current" : "cm-comment-highlight";
+			const range = EditorSelection.range(from, to);
+			const markers = RectangleMarker.forRange(view, className, range);
+			return markers.length === 1 ? RectangleMarker.forRange(view, `${className} cm-comment-highlight-single`, range) : markers;
+		});
+	}
+});
+var handleCommentClick = EditorView.domEventHandlers({ click: (event, view) => {
+	const id = commentIdAtClick(event, view);
+	if (!id) return false;
+	scrollCommentIntoView(view, id);
+	view.state.facet(optionsFacet).onActivate?.(id);
+	return true;
+} });
+/**
+* Resolve the comment id under a click. Prefers the DOM target (a direct hit on the `.cm-comment`
+* span), then falls back to a document-position hit-test: the highlight-layer rectangles
+* (pointer-events: none) sit over the text, so a click often lands on the `.cm-line` (an ancestor of
+* the span) and an upward target walk would miss it.
+*/
+var commentIdAtClick = (event, view) => {
+	let target = event.target;
+	const editorRoot = view.dom;
+	while (target && target !== editorRoot && !target.hasAttribute?.("data-comment-id")) target = target.parentElement;
+	const domId = target && target !== editorRoot ? target.getAttribute("data-comment-id") : null;
+	if (domId) return domId;
+	const pos = view.posAtCoords({
+		x: event.clientX,
+		y: event.clientY
+	});
+	if (pos != null) return view.state.field(commentsState, false)?.comments.find(({ range }) => pos >= range.from && pos <= range.to)?.comment.id;
+};
+var trackPastedComments = (onUpdate) => {
+	let tracked = null;
+	const handleTrack = (event, view) => {
+		const comments = view.state.field(commentsState);
+		const { main } = view.state.selection;
+		const selectedRanges = comments.comments.filter(({ range }) => range.from >= main.from && range.to <= main.to && range.from < range.to);
+		if (!selectedRanges.length) tracked = null;
+		else tracked = {
+			text: view.state.doc.slice(main.from, main.to),
+			comments: selectedRanges.map(({ comment, range }) => ({
+				id: comment.id,
+				from: range.from - main.from,
+				to: range.to - main.from
+			}))
+		};
+	};
+	return [
+		EditorView.domEventHandlers({
+			cut: handleTrack,
+			copy: handleTrack
+		}),
+		invertedEffects.of((tr) => {
+			const { comments } = tr.startState.field(commentsState);
+			const effects = [];
+			tr.changes.iterChangedRanges((fromA, toA) => {
+				for (const { comment: { id }, range: { from, to } } of comments) if (from < to && from >= fromA && to <= toA) effects.push(restoreCommentEffect.of({
+					id,
+					from,
+					to
+				}));
+			});
+			return effects;
+		}),
+		EditorView.updateListener.of((update) => {
+			const restore = [];
+			for (let i = 0; i < update.transactions.length; i++) {
+				const tr = update.transactions[i];
+				for (let j = 0; j < restore.length; j++) restore[j] = mapTrackedComment(restore[j], tr.changes);
+				for (const effect of tr.effects) if (effect.is(restoreCommentEffect)) restore.push(effect.value);
+			}
+			if (tracked) {
+				const paste = update.transactions.find((tr) => tr.isUserEvent("input.paste"));
+				if (paste) {
+					let found = -1;
+					paste.changes.iterChanges((fromA, toA, fromB, toB, text) => {
+						if (text.eq(tracked.text)) {
+							for (let i = update.transactions.indexOf(paste) + 1; i < update.transactions.length; i++) fromB = update.transactions[i].changes.mapPos(fromB);
+							found = fromB;
+						}
+					});
+					if (found > -1) for (const moved of tracked.comments) restore.push({
+						id: moved.id,
+						from: found + moved.from,
+						to: found + moved.to
+					});
+					tracked = null;
+				}
+			}
+			for (const comment of restore) {
+				const { comments } = update.startState.field(commentsState);
+				if (!comments.some((c) => c.comment.id === comment.id && c.range.from < c.range.to)) {
+					const cursor = Cursor.getCursorFromRange(update.state, comment);
+					onUpdate({
+						id: comment.id,
+						cursor
+					});
+				}
+			}
+		})
+	];
+};
+var mapTrackedComment = (comment, changes) => ({
+	id: comment.id,
+	from: changes.mapPos(comment.from, 1),
+	to: changes.mapPos(comment.to, 1)
+});
+/**
+* These are attached to undone/redone transactions in the editor for the purpose of restoring comments
+* that were deleted by the original changes.
+*/
+var restoreCommentEffect = StateEffect.define({ map: mapTrackedComment });
+var optionsFacet = singleValueFacet();
+/**
+* Create comment thread action.
+*/
+var createComment = (view) => {
+	const options = view.state.facet(optionsFacet);
+	if (options.readonly) return false;
+	let { from, to } = view.state.selection.main;
+	const chunk = getChunks(view.state)?.chunks.find((candidate) => candidate.fromB <= to && candidate.endB >= from);
+	if (chunk) {
+		from = chunk.fromB;
+		to = Math.min(chunk.endB, view.state.doc.length);
+	} else if (from === to) {
+		const word = view.state.wordAt(from);
+		if (word) {
+			from = word.from;
+			to = word.to;
+		}
+	}
+	while (to > from && view.state.doc.sliceString(to - 1, to) === "\n") to--;
+	if (from === to) return false;
+	const cursor = Cursor.getCursorFromRange(view.state, {
+		from,
+		to
+	});
+	if (cursor) {
+		view.dispatch({ selection: { anchor: from } });
+		options.onCreate?.({
+			cursor,
+			from,
+			location: view.coordsAtPos(from),
+			branch: options.reviewBranch
+		});
+		return true;
+	}
+	return false;
+};
+/**
+* Whether the [from, to] document range is entirely within the editor's scroll
+* viewport. Returns false if either endpoint isn't currently rendered (off-screen).
+*/
+var isRangeVisible = (view, range) => {
+	const from = view.coordsAtPos(range.from);
+	const to = view.coordsAtPos(range.to);
+	if (!from || !to) return false;
+	const { top, bottom } = view.scrollDOM.getBoundingClientRect();
+	return from.top >= top && to.bottom <= bottom;
+};
+/**
+* Scroll the comment thread with the given id into view (if not already entirely
+* visible) and mark it the current comment so the editor highlights it.
+*/
+var scrollCommentIntoView = (view, id, { y = "center", yMargin } = {}) => {
+	const comment = view.state.field(commentsState).comments.find((range) => range.comment.id === id);
+	if (!comment?.comment.cursor) return;
+	const range = Cursor.getRangeFromCursor(view.state, comment.comment.cursor);
+	if (!range) return;
+	const { from, to } = view.state.selection.main;
+	const needsSelectionUpdate = from === to && from !== range.from;
+	view.dispatch({
+		selection: needsSelectionUpdate ? { anchor: range.from } : void 0,
+		effects: [isRangeVisible(view, range) ? [] : EditorView.scrollIntoView(range.from, {
+			y,
+			yMargin
+		}), setSelection.of({ current: id })].flat()
+	});
+};
+/**
+* NOTE: Matches search.
+*/
+var styles = EditorView.theme({
+	".cm-comment, .cm-comment *": { color: "var(--color-teal-fg) !important" },
+	".cm-comment[data-current=\"1\"], .cm-comment[data-current=\"1\"] *": { color: "var(--color-orange-fg) !important" },
+	".cm-comment": { cursor: "pointer" },
+	".cm-commentsHighlightLayer": { pointerEvents: "none" },
+	".cm-comment-highlight": {
+		backgroundColor: "var(--color-teal-bg)",
+		boxShadow: "0 0 0 1px var(--color-teal-bg)",
+		boxSizing: "content-box",
+		marginInline: "-2px",
+		paddingInline: "2px",
+		pointerEvents: "none"
+	},
+	".cm-comment-highlight-current": {
+		backgroundColor: "var(--color-orange-bg)",
+		boxShadow: "0 0 0 1px var(--color-orange-bg)"
+	},
+	".cm-comment-highlight-single": { borderRadius: "0.25rem" }
+});
+//#endregion
+//#region src/extensions/review/diff.ts
+/**
+* Orient the diff as a preview of accepting the original (the compared branch) into the editor's
+* document (the current branch): the compare branch's content — which the merge view renders as
+* deletions because it is absent from the editor — is what accepting ADDS, so show it as an addition;
+* the current branch's deviating content is what accepting REMOVES. This overrides the merge view's
+* default green-editor / red-original colouring, which reads inverted for branch review.
+*/
+var reviewOrientationTheme = EditorView.theme({
+	"&.cm-merge-b .cm-changedLine, &.cm-merge-b .cm-changedText": { backgroundColor: "var(--color-cm-diff-remove-surface)" },
+	"& .cm-deletedChunk, & .cm-deletedChunk .cm-deletedText": {
+		backgroundColor: "var(--color-cm-diff-add-surface)",
+		textDecoration: "none"
+	},
+	"&.cm-merge-b .cm-changedLineGutter": { background: "var(--color-cm-diff-remove-gutter)" },
+	"& .cm-deletedLineGutter": { background: "var(--color-cm-diff-add-gutter)" }
+});
+/**
+* Inline (unified) diff view: renders the editor's document with insertions and deletions marked
+* relative to {@link DiffOptions.original}. The editor stays editable — edits to the document update
+* the diff against the (static) original live — so it can overlay a live editor to compare the
+* current state against another version (e.g. another branch) without locking editing.
+*/
+var diffView = ({ original }) => [unifiedMergeView({
+	original,
+	mergeControls: false
+}), reviewOrientationTheme];
+/**
+* Groups the word-level diff between `before` and `after` into contiguous {@link DiffHunk}s — each a
+* maximal run of insertions/deletions bounded by unchanged text. Used to render Google-Docs-style
+* suggestions (accept/reject per hunk) over the original document (see {@link suggestChanges}).
+*/
+var diffHunks = (before, after) => {
+	const hunks = [];
+	let position = 0;
+	let pending;
+	const minimize = (hunk) => {
+		const { removed, inserted } = hunk;
+		let prefix = 0;
+		while (prefix < removed.length && prefix < inserted.length && removed[prefix] === inserted[prefix]) prefix++;
+		let suffix = 0;
+		while (suffix < removed.length - prefix && suffix < inserted.length - prefix && removed[removed.length - 1 - suffix] === inserted[inserted.length - 1 - suffix]) suffix++;
+		if (prefix + suffix !== removed.length && prefix + suffix !== inserted.length) return hunk;
+		return {
+			from: hunk.from + prefix,
+			to: hunk.to - suffix,
+			removed: removed.slice(prefix, removed.length - suffix),
+			inserted: inserted.slice(prefix, inserted.length - suffix)
+		};
+	};
+	const flush = () => {
+		if (pending) {
+			hunks.push(minimize(pending));
+			pending = void 0;
+		}
+	};
+	for (const change of diffWordsWithSpace(before, after)) if (change.added) {
+		pending ??= {
+			from: position,
+			to: position,
+			removed: "",
+			inserted: ""
+		};
+		pending.inserted += change.value;
+	} else if (change.removed) {
+		pending ??= {
+			from: position,
+			to: position,
+			removed: "",
+			inserted: ""
+		};
+		pending.removed += change.value;
+		pending.to = position + change.value.length;
+		position += change.value.length;
+	} else {
+		flush();
+		position += change.value.length;
+	}
+	flush();
+	return hunks;
+};
+var groupHunks = (hunks, before, policy = {}) => {
+	const { maxGap = 0, respectBlockBoundaries = true } = policy;
+	const groups = [];
+	for (const hunk of hunks) {
+		const previous = groups.at(-1);
+		const gap = previous ? before.slice(previous.to, hunk.from) : "";
+		if (previous !== void 0 && gap.length <= maxGap && !(respectBlockBoundaries && /\n[ \t]*\n/.test(gap))) {
+			previous.to = hunk.to;
+			previous.removed += gap + hunk.removed;
+			previous.inserted += gap + hunk.inserted;
+		} else groups.push({ ...hunk });
+	}
+	return groups;
+};
+/** Markdown delimiter pairs that must be suggested — and applied — atomically. */
+var MARKUP_DELIMITERS = /* @__PURE__ */ new Set([
+	"**",
+	"__",
+	"*",
+	"_",
+	"~~",
+	"`"
+]);
+/**
+* Coalesces two pure insertions forming a matched markdown delimiter pair around intervening text
+* (e.g. `**` before and after a phrase) into ONE replace hunk spanning the wrapped text. Without
+* this, wrapping MULTIPLE words diffs as two zero-width inserts, and accepting either half alone
+* leaves broken syntax. Only a tight wrap (same line, non-empty gap) reads as one formatting action.
+*/
+var pairMarkupHunks = (hunks, before) => {
+	const result = [];
+	for (let index = 0; index < hunks.length; index++) {
+		const open = hunks[index];
+		const close = hunks[index + 1];
+		if (close !== void 0 && open.from === open.to && close.from === close.to && close.from > open.from && MARKUP_DELIMITERS.has(open.inserted) && close.inserted === open.inserted) {
+			const gap = before.slice(open.from, close.from);
+			if (gap.length > 0 && !gap.includes("\n")) {
+				result.push({
+					from: open.from,
+					to: close.from,
+					removed: gap,
+					inserted: open.inserted + gap + close.inserted
+				});
+				index++;
+				continue;
+			}
+		}
+		result.push(open);
+	}
+	return result;
+};
+/**
+* Re-anchors {@link DiffHunk}s computed against `base` into `doc` coordinates, so a foreign author's
+* proposal (diffed `base` vs proposal) can be decorated over a `doc` that has itself diverged from
+* `base` (the user's own branch edits). Each hunk offset is mapped through the character-level
+* `base`↔`doc` diff ({@link computeCharHunks}): a position in an unchanged region shifts by the net
+* length of edits before it; a position inside a doc-edited region clamps to that region's edge (the
+* `from` to its start, the `to` to its end). Without this, a proposal diffed against `base` would
+* render at stale offsets over the diverged `doc`.
+*/
+var rebaseHunks = (base, doc, hunks) => rebaseHunksWith(computeCharHunks(base, doc), hunks);
+/**
+* {@link rebaseHunks} with a precomputed `base`↔`doc` character diff. Callers rebasing MANY hunk sets
+* against the same pair — e.g. every author's proposal over one branch (see {@link suggestions}) —
+* compute {@link computeCharHunks} once and reuse it, rather than re-diffing the whole document per set.
+*/
+var rebaseHunksWith = (charHunks, hunks) => {
+	const mapPos = (pos, side) => {
+		let delta = 0;
+		for (const hunk of charHunks) {
+			if (pos < hunk.fromA) break;
+			if (pos === hunk.fromA) return hunk.fromB;
+			if (pos < hunk.toA) return side < 0 ? hunk.fromB : hunk.toB;
+			delta = hunk.toB - hunk.toA;
+		}
+		return pos + delta;
+	};
+	return hunks.map((hunk) => {
+		if (hunk.from === hunk.to) {
+			const at = mapPos(hunk.from, -1);
+			return {
+				...hunk,
+				from: at,
+				to: at
+			};
+		}
+		return {
+			...hunk,
+			from: mapPos(hunk.from, -1),
+			to: mapPos(hunk.to, 1)
+		};
+	});
+};
+/**
+* LINE-level changed hunks between `original` (A) and `modified` (B) as character ranges (via
+* `@codemirror/merge` `Chunk.build`). Coarser than {@link computeWordHunks}; retained for callers that
+* want whole-line change regions.
+*/
+var computeHunks = (original, modified) => Chunk.build(Text.of(original.split("\n")), Text.of(modified.split("\n"))).map((chunk) => ({
+	fromA: chunk.fromA,
+	toA: chunk.toA,
+	fromB: chunk.fromB,
+	toB: chunk.toB
+}));
+/**
+* WORD-level changed hunks between `original` (A) and `modified` (B), each carrying both coordinate
+* ranges. Matches the word granularity of {@link diffHunks} (same `diffWordsWithSpace` alignment), so
+* {@link cherryPickHunk} / {@link revertHunk} resolve exactly the anchored word(s) — accepting one
+* word does not pull in the rest of its line.
+*/
+var computeWordHunks = (original, modified) => {
+	const hunks = [];
+	let positionA = 0;
+	let positionB = 0;
+	let pending;
+	const flush = () => {
+		if (pending) {
+			hunks.push(pending);
+			pending = void 0;
+		}
+	};
+	for (const change of diffWordsWithSpace(original, modified)) if (change.added) {
+		pending ??= {
+			fromA: positionA,
+			toA: positionA,
+			fromB: positionB,
+			toB: positionB
+		};
+		positionB += change.value.length;
+		pending.toB = positionB;
+	} else if (change.removed) {
+		pending ??= {
+			fromA: positionA,
+			toA: positionA,
+			fromB: positionB,
+			toB: positionB
+		};
+		positionA += change.value.length;
+		pending.toA = positionA;
+	} else {
+		flush();
+		positionA += change.value.length;
+		positionB += change.value.length;
+	}
+	flush();
+	return hunks;
+};
+/**
+* CHARACTER-level changed hunks between `original` (A) and `modified` (B), each carrying both
+* coordinate ranges. Finer than {@link computeWordHunks}: an in-word or whitespace/newline edit shows
+* only the changed characters, not a whole-word delete+insert. Used for live "Suggesting mode" tracked
+* changes (see {@link trackChanges}), where word granularity makes every keystroke read as a struck
+* word rebuilt beside it.
+*/
+var computeCharHunks = (original, modified) => joinNearbyHunks(wordHunks(original, modified)).map((hunk) => trimCommonAffixes(original, modified, hunk)).map((hunk) => slideToWordBoundary(original, modified, hunk));
+/**
+* Unchanged text shorter than this between two changed regions does not separate them: a selection
+* that cuts into the words at each end leaves a word fragment on both sides of a single space, and
+* reporting those as two changes strikes text the reader never touched.
+*/
+var MIN_COMMON_RUN = 4;
+/** Merges hunks separated by less unchanged text than {@link MIN_COMMON_RUN}, absorbing the gap. */
+var joinNearbyHunks = (hunks) => {
+	const merged = [];
+	for (const hunk of hunks) {
+		const previous = merged.at(-1);
+		if (previous && hunk.fromA - previous.toA < MIN_COMMON_RUN && hunk.fromB - previous.toB < MIN_COMMON_RUN) {
+			previous.toA = hunk.toA;
+			previous.toB = hunk.toB;
+		} else merged.push({ ...hunk });
+	}
+	return merged;
+};
+/** Accumulates a diff's changed regions into {@link Hunk}s, given a tokenisation of the two texts. */
+var accumulate = (changes) => {
+	const hunks = [];
+	let positionA = 0;
+	let positionB = 0;
+	let pending;
+	const flush = () => {
+		if (pending) {
+			hunks.push(pending);
+			pending = void 0;
+		}
+	};
+	for (const change of changes) if (change.added) {
+		pending ??= {
+			fromA: positionA,
+			toA: positionA,
+			fromB: positionB,
+			toB: positionB
+		};
+		positionB += change.value.length;
+		pending.toB = positionB;
+	} else if (change.removed) {
+		pending ??= {
+			fromA: positionA,
+			toA: positionA,
+			fromB: positionB,
+			toB: positionB
+		};
+		positionA += change.value.length;
+		pending.toA = positionA;
+	} else {
+		flush();
+		positionA += change.value.length;
+		positionB += change.value.length;
+	}
+	flush();
+	return hunks;
+};
+var wordHunks = (original, modified) => accumulate(diffWordsWithSpace(original, modified));
+/**
+* Shrinks a word-level hunk to the characters that actually changed, by dropping the prefix and suffix
+* its two sides share. Word granularity is what keeps one edit from fragmenting into strikes with
+* untouched letters marooned between them, but on its own it reports whole words: a deletion cutting
+* into the words at each end fuses the survivors, and the hunk then reads as "delete both words, insert
+* this fused one". Trimming leaves exactly the range the reader removed (or typed).
+*/
+var trimCommonAffixes = (original, modified, hunk) => {
+	const removed = original.slice(hunk.fromA, hunk.toA);
+	const inserted = modified.slice(hunk.fromB, hunk.toB);
+	const limit = Math.min(removed.length, inserted.length);
+	let prefix = 0;
+	while (prefix < limit && removed[prefix] === inserted[prefix]) prefix++;
+	let suffix = 0;
+	while (suffix < limit - prefix && removed[removed.length - 1 - suffix] === inserted[inserted.length - 1 - suffix]) suffix++;
+	return {
+		fromA: hunk.fromA + prefix,
+		toA: hunk.toA - suffix,
+		fromB: hunk.fromB + prefix,
+		toB: hunk.toB - suffix
+	};
+};
+/**
+* Slides a one-sided hunk (a pure deletion or insertion) to the word boundary that encloses it. Which
+* characters a one-sided edit removed is ambiguous whenever text repeats around it: deleting
+* `suggest change` from `suggest changes` leaves an `s` that is equally the head of the first word or
+* the tail of the last, and the minimal-edit answer strikes `uggest changes` — keeping a letter of the
+* word the reader deleted. Rotating the span while it still describes the same edit lets it settle
+* where a reader would draw it.
+*/
+var slideToWordBoundary = (original, modified, hunk) => {
+	const deletion = hunk.toB === hunk.fromB;
+	if (deletion === (hunk.toA === hunk.fromA)) return hunk;
+	const text = deletion ? original : modified;
+	const from = deletion ? hunk.fromA : hunk.fromB;
+	const to = deletion ? hunk.toA : hunk.toB;
+	const atBoundary = (offset) => offset === 0 || /\s/.test(text[offset - 1]);
+	if (atBoundary(from)) return hunk;
+	for (let shift = 1; shift <= from; shift++) {
+		if (text[from - shift] !== text[to - shift]) break;
+		if (atBoundary(from - shift)) return {
+			fromA: hunk.fromA - shift,
+			toA: hunk.toA - shift,
+			fromB: hunk.fromB - shift,
+			toB: hunk.toB - shift
+		};
+	}
+	return hunk;
+};
+/**
+* Does a hunk cover the anchored range? Half-open, so a range touching a neighbouring hunk's
+* boundary is not on that hunk — except where either side is empty, which is the normal shape of a
+* pure insertion: the inserted text occupies no span on the other side, and the caller anchors it at
+* a single offset. Those collapse to a containment test, or accepting an insertion is impossible.
+*/
+var overlaps = (from, to, range) => from === to || range.start === range.end ? from <= range.end && to >= range.start : from < range.end && to > range.start;
+/**
+* Resolve a single change to apply when cherry-picking from `compare` (A) into `current` (B): find
+* the hunk overlapping `range` (a character range in `current`) and return the splice that replaces
+* that hunk's current text with the compare version. Returns undefined if no hunk overlaps the range
+* (e.g. the change was already applied/reverted). `compare` is read live by the caller, so applying
+* the result always reflects the latest diff — not a snapshot.
+*/
+var cherryPickHunk = (current, compare, range) => {
+	const matched = computeWordHunks(compare, current).filter((h) => overlaps(h.fromB, h.toB, range));
+	if (matched.length === 0) return;
+	const first = matched[0];
+	const last = matched[matched.length - 1];
+	return {
+		from: first.fromB,
+		del: Math.min(last.toB, current.length) - first.fromB,
+		insert: compare.slice(first.fromA, Math.min(last.toA, compare.length))
+	};
+};
+/**
+* Resolve the splice that reverts a single change on `compare` (a branch) back to `base` (main) —
+* the reject counterpart to {@link cherryPickHunk}. `baseRange` is a character range in `base`; the
+* hunk overlapping it is located and the returned splice (in `compare` coordinates) replaces the
+* branch's version with the base text. Returns undefined if no hunk overlaps the range.
+*/
+var revertHunk = (base, compare, baseRange) => {
+	const matched = computeWordHunks(base, compare).filter((h) => overlaps(h.fromA, h.toA, baseRange));
+	if (matched.length === 0) return;
+	const first = matched[0];
+	const last = matched[matched.length - 1];
+	return {
+		from: first.fromB,
+		del: Math.min(last.toB, compare.length) - first.fromB,
+		insert: base.slice(first.fromA, Math.min(last.toA, base.length))
+	};
+};
+//#endregion
+export { singleValueFacet as A, selectionState as C, wrapWithCatch as D, logChanges as E, Cursor as O, documentId as S, join as T, setComments as _, diffHunks as a, EditorSelectionStateSchema as b, pairMarkupHunks as c, revertHunk as d, comments as f, scrollCommentIntoView as g, isRangeVisible as h, computeWordHunks as i, overlap as k, rebaseHunks as l, createComment as m, computeCharHunks as n, diffView as o, commentsState as p, computeHunks as r, groupHunks as s, cherryPickHunk as t, rebaseHunksWith as u, setSelection as v, debugDispatcher as w, createEditorStateTransaction as x, EditorSelection$1 as y };
+
+//# sourceMappingURL=chunk-diff.mjs.map